import { getBaseURL } from '@/assets/js/config'; // 引入获取基础URL的函数

const baseURL = getBaseURL();

// API路径配置
const API_PATHS = { 
  AI_CHAT: `${baseURL}/user/ai/chat` // AI聊天接口路径
};

// 全局变量
let abortController = null; // 用于中断fetch请求的控制器
let typingIntervals = new Map(); // 存储所有打字机效果的interval（键值对：消息ID => interval）

/**
 * 将文件转换为Base64编码
 * @param {File} file - 文件对象
 * @returns {Promise<string>} - Base64编码字符串
 */
function fileToBase64(file) {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.readAsDataURL(file);
    reader.onload = () => {
      // 移除"data:image/jpeg;base64,"这样的前缀，只保留Base64内容
      const base64String = reader.result.split(',')[1];
      resolve(base64String);
    };
    reader.onerror = error => reject(error);
  });
}

/**
 * 启动带打字机效果的流式聊天连接（兼容非标准SSE格式）
 *   @param {Object} params - 请求参数
 *   @param {string} params.prompt - 用户输入内容
 *   @param {string} params.agentType - 代理类型
 *   @param {boolean} params.hasFile - 是否有文件
 *   @param {File} [params.file] - 文件对象
 *   @param {Object} callbacks - 回调函数集
 *   @param {Function} callbacks.onMessage - 消息回调(content: string, isDone: boolean)
 *   @param {Function} [callbacks.onError] - 错误回调(error: Error)
 */
async function startTypingStream(params, callbacks = {}) {
  // 1. 清理现有连接和效果
  closeChatStream();
  
  try {
    // 2. 初始化请求控制器
    abortController = new AbortController();
    const messageId = Date.now();

    // 3. 初始化流式状态
    let fullMessage = '';
    let displayedContent = '';
    let streamBuffer = '';
    let lastProcessTime = Date.now();
    let isComplete = false;
    const MIN_INTERVAL = 30;
    
    // 4. 准备请求数据
    let requestHeaders = {
      'Authorization': `${localStorage.getItem('token')}`,
      'Accept': 'text/event-stream',
      'Content-Type': 'application/json'
    };

    // 准备请求参数对象
    const requestParams = {
      prompt: params.prompt || '',
      agentType: params.agentType || 'question',
      hasFile: params.hasFile || false,
      userId: params.userId || '',
      sessionId: params.sessionId || ''
    };

    // 如果有文件，添加文件相关信息
    if (params.hasFile && params.file) {
      try {
        const base64 = await fileToBase64(params.file);
        requestParams.hasFile = true;
        requestParams.fileName = params.file.name;
        requestParams.fileBase64 = base64;
        requestParams.fileType = params.file.type;
      } catch (error) {
        console.error('文件转Base64失败:', error);
        callbacks.onError?.(new Error('文件处理失败'));
        return;
      }
    }

    const requestData = JSON.stringify(requestParams);
    
    // 5. 发起流式请求
    const response = await fetch(API_PATHS.AI_CHAT, {
      method: 'POST',
      headers: requestHeaders,
      body: requestData,
      signal: abortController.signal
    });

    if (!response.ok) {
      throw new Error(`HTTP ${response.status}`);
    }

    // 6. 创建流式读取器
    const reader = response.body.getReader();
    const decoder = new TextDecoder();
    let buffer = '';

    // 7. 启动打字效果处理器
    const processTypingEffect = async () => {
      if (!streamBuffer) return;
      
      const now = Date.now();
      const timeSinceLastProcess = now - lastProcessTime;
      
      if (timeSinceLastProcess < MIN_INTERVAL) {
        await new Promise(resolve => setTimeout(resolve, MIN_INTERVAL - timeSinceLastProcess));
      }
      
      const charsToAdd = Math.min(
        Math.max(1, Math.floor(streamBuffer.length / 50)),
        3
      );
      
      if (charsToAdd > 0) {
        const newContent = streamBuffer.substring(0, charsToAdd);
        streamBuffer = streamBuffer.substring(charsToAdd);
        displayedContent += newContent;
        // 传递打字状态
        callbacks.onMessage?.(displayedContent, isComplete);
        lastProcessTime = Date.now();
      }
    };

    // 8. 设置打字效果定时器
    const typingInterval = setInterval(processTypingEffect, 16);
    typingIntervals.set(messageId, typingInterval);

    // 9. 持续读取流数据
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;

      buffer += decoder.decode(value, { stream: true });
      const chunks = buffer.split('data:');
      buffer = chunks.pop() || '';

      for (const chunk of chunks) {
        if (!chunk.trim()) continue;

        // 10. 检查完成标记
        if (chunk.includes('[complete]')) {
          // 确保显示所有剩余内容
          if (streamBuffer) {
            while (streamBuffer.length > 0) {
              await processTypingEffect();
            }
            isComplete = true;
            callbacks.onMessage?.(displayedContent, true);
          }
          stopTypingEffect(messageId);
          return;
        }

        const content = chunk.trim();
        fullMessage += content;
        streamBuffer += content;
        await processTypingEffect();
      }
    }

    // 12. 流结束处理
    if (streamBuffer) {
      while (streamBuffer.length > 0) {
        await processTypingEffect();
      }
      isComplete = true;
      callbacks.onMessage?.(displayedContent, true);
    }
    stopTypingEffect(messageId);

  } catch (error) {
    if (error.name !== 'AbortError') {
      stopAllTypingEffects();
      callbacks.onError?.(error);
    }
  }
}

/**
 * 停止指定消息的打字效果
 * @param {number} id - 消息唯一ID
 */
function stopTypingEffect(id) {
  if (typingIntervals.has(id)) {
    clearInterval(typingIntervals.get(id));
    typingIntervals.delete(id);
  }
}

/**
 * 停止所有打字效果
 */
function stopAllTypingEffects() {
  typingIntervals.forEach((interval, id) => {
    clearInterval(interval);
    typingIntervals.delete(id);
  });
}

/**
 * 主动关闭连接（清理资源）
 */
function closeChatStream() {
  // 1. 中断fetch请求
  if (abortController) {
    abortController.abort();
    abortController = null;
  }
  
  // 2. 停止所有打字效果
  stopAllTypingEffects();
}

// 导出API方法
export default {
  startTypingStream, // 启动带打字效果的流式连接
  closeChatStream    // 手动关闭连接
};